home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / ungepackte_daten / 1994 / 8 / 05 / term-4.0-source.lha / termRemember.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-07-05  |  8.7 KB  |  469 lines
  1. /*
  2. **    termRemember.c
  3. **
  4. **    Login learn routines
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10.     /* How many characters to remember. */
  11.  
  12. #define REMEMBER_OUT    40
  13. #define REMEMBER_IN    256
  14.  
  15.     /* Yet another node variant. */
  16.  
  17. struct RecordNode
  18. {
  19.     struct Node    Node;
  20.     struct timeval    Time;
  21. };
  22.  
  23.     /* What type of text was recorded. */
  24.  
  25. enum    {    RECORD_OUTPUT,RECORD_INPUT };
  26.  
  27.     /* The last ten bytes received. */
  28.  
  29. STATIC UBYTE         RememberOutputData[2 * REMEMBER_OUT + 10];
  30. STATIC WORD         RememberOutputSize;
  31.  
  32.     /* The last 256 bytes sent. */
  33.  
  34. STATIC UBYTE         RememberInputData[2 * REMEMBER_IN + 10];
  35. STATIC WORD         RememberInputSize;
  36.  
  37.     /* The name of the BBS we are currently recording for. */
  38.  
  39. STATIC UBYTE         RecordName[50];
  40.  
  41.     /* Recorded lines. */
  42.  
  43. STATIC struct List    *RecordList;
  44. STATIC LONG         RecordCount;
  45.  
  46.     /* Auxilary data. */
  47.  
  48. STATIC STRPTR         RecordAuxBuffer;
  49.  
  50.     /* Start of recording. */
  51.  
  52. STATIC struct timeval     RecordTime;
  53.  
  54.     /* FinishRecord():
  55.      *
  56.      *    Finish the recording process, store the
  57.      *    recorded data in a file.
  58.      */
  59.  
  60. VOID
  61. FinishRecord()
  62. {
  63.     if(RecordCount)
  64.     {
  65.         UBYTE             DummyBuffer[MAX_FILENAME_LENGTH];
  66.         struct FileRequester    *FileRequest;
  67.  
  68.         BlockWindows();
  69.  
  70.         Recording = RecordingLine = FALSE;
  71.  
  72.         Status = STATUS_READY;
  73.  
  74.         if(RecordName[0])
  75.             strcpy(DummyBuffer,RecordName);
  76.         else
  77.         {
  78.             strcpy(DummyBuffer,LocaleString(MSG_SCREENPANEL_UNKNOWN_TXT));
  79.  
  80.             strcpy(RecordName,DummyBuffer);
  81.         }
  82.  
  83.         FixName(DummyBuffer);
  84.  
  85.         DummyBuffer[27] = 0;
  86.  
  87.         strcat(DummyBuffer,".term");
  88.  
  89.         if(FileRequest = GetFile(Window,LocaleString(MSG_SAVE_RECORDED_FILE_TXT),"",DummyBuffer,DummyBuffer,"#?.(term|rexx)",TRUE,FALSE,FALSE,LocaleString(MSG_GLOBAL_SAVE_GAD),TRUE))
  90.         {
  91.             BPTR        FileHandle;
  92.             LONG        Error = 0;
  93.             struct timeval    Delta = { 0,0 };
  94.  
  95.             if(FileHandle = Open(DummyBuffer,MODE_NEWFILE))
  96.             {
  97.                 SetIoErr(0);
  98.  
  99.                 if(FPrintf(FileHandle,LocaleString(MSG_RECORDFILE_HEADER_TXT),RecordName) < 1)
  100.                     Error = IoErr();
  101.  
  102.                 if(!Error)
  103.                 {
  104.                     struct RecordNode *Node = (struct RecordNode *)RecordList -> lh_Head;
  105.  
  106.                     while(Node -> Node . ln_Succ && !Error)
  107.                     {
  108.                         if(Delta . tv_secs != Node -> Time . tv_secs)
  109.                         {
  110.                             LONG Secs;
  111.  
  112.                             Secs = (3 * Node -> Time . tv_secs) / 2 + (3 * Node -> Time . tv_micro) / 2000000;
  113.  
  114.                             SetIoErr(0);
  115.  
  116.                             if(FPrintf(FileHandle,"TIMEOUT %ld\n",Secs) < 1)
  117.                             {
  118.                                 Error = IoErr();
  119.  
  120.                                 break;
  121.                             }
  122.                             else
  123.                                 Delta = Node -> Time;
  124.                         }
  125.  
  126.                         SetIoErr(0);
  127.  
  128.                         if(Node -> Node . ln_Type == RECORD_OUTPUT)
  129.                         {
  130.                             if(FPrintf(FileHandle,"WAIT TEXT \"%s\"\n",Node -> Node . ln_Name) < 1)
  131.                                 Error = IoErr();
  132.                         }
  133.                         else
  134.                         {
  135.                             if(FPrintf(FileHandle,"SEND TEXT \"%s\"\n\n",Node -> Node . ln_Name) < 1)
  136.                                 Error = IoErr();
  137.                         }
  138.  
  139.                         Node = (struct RecordNode *)Node -> Node. ln_Succ;
  140.                     }
  141.                 }
  142.  
  143.                 Close(FileHandle);
  144.  
  145.                 if(ChosenEntry)
  146.                 {
  147.                     if(MyEasyRequest(Window,LocaleString(MSG_USE_AS_LOGIN_SCRIPT_TXT),LocaleString(MSG_GLOBAL_YES_NO_TXT),ChosenEntry -> Header -> Name))
  148.                     {
  149.                         if(!ChosenEntry -> Config -> CommandConfig)
  150.                         {
  151.                             if(!CreateConfigEntry(ChosenEntry -> Config,PREF_COMMAND))
  152.                                 ShowError(Window,ERR_NO_MEM,NULL,NULL);
  153.                         }
  154.  
  155.                         if(ChosenEntry -> Config -> CommandConfig)
  156.                         {
  157.                             PhonebookChanged = TRUE;
  158.  
  159.                             SPrintf(ChosenEntry -> Config -> CommandConfig -> LoginMacro,"\\a %s",DummyBuffer);
  160.                         }
  161.                     }
  162.                 }
  163.             }
  164.             else
  165.                 Error = IoErr();
  166.  
  167.             if(!Error && Config -> MiscConfig -> CreateIcons && IconBase)
  168.             {
  169.                 struct DiskObject *Icon;
  170.  
  171.                 if(!(Icon = GetDiskObject("ENV:def_term")))
  172.                 {
  173.                     if(!(Icon = GetDiskObject("ENV:def_rexx")))
  174.                     {
  175.                         if(Icon = GetDefDiskObject(WBPROJECT))
  176.                             Icon -> do_DefaultTool = "RX";
  177.                     }
  178.                 }
  179.  
  180.                 if(Icon)
  181.                 {
  182.                     Icon -> do_CurrentX = Icon -> do_CurrentY = NO_ICON_POSITION;
  183.  
  184.                     PutDiskObject(DummyBuffer,Icon);
  185.  
  186.                     FreeDiskObject(Icon);
  187.                 }
  188.             }
  189.  
  190.             if(Error)
  191.                 ShowError(Window,ERR_SAVE_ERROR,Error,DummyBuffer);
  192.  
  193.             FreeAslRequest(FileRequest);
  194.         }
  195.  
  196.         DeleteRecord();
  197.  
  198.         ReleaseWindows();
  199.     }
  200. }
  201.  
  202.     /* CreateRecord(STRPTR BBSName):
  203.      *
  204.      *    Start recording incoming and outgoing text.
  205.      */
  206.  
  207. BOOLEAN __regargs
  208. CreateRecord(STRPTR BBSName)
  209. {
  210.     DeleteRecord();
  211.  
  212.     if(RecordList = (struct List *)AllocVecPooled(sizeof(struct List),MEMF_ANY))
  213.     {
  214.         if(RecordAuxBuffer = (STRPTR)AllocVecPooled(1024,MEMF_ANY))
  215.         {
  216.             strcpy(RecordName,BBSName);
  217.  
  218.             NewList(RecordList);
  219.  
  220.             TimeRequest -> tr_node . io_Command = TR_GETSYSTIME;
  221.  
  222.             DoIO(TimeRequest);
  223.  
  224.             RecordTime = TimeRequest -> tr_time;
  225.  
  226.             return(TRUE);
  227.         }
  228.  
  229.         FreeVecPooled(RecordList);
  230.  
  231.         RecordList = NULL;
  232.     }
  233.  
  234.     return(FALSE);
  235. }
  236.  
  237.     /* DeleteRecord():
  238.      *
  239.      *    Stop recording, free auxilary buffers.
  240.      */
  241.  
  242. VOID
  243. DeleteRecord()
  244. {
  245.     if(RecordAuxBuffer)
  246.     {
  247.         FreeVecPooled(RecordAuxBuffer);
  248.  
  249.         RecordAuxBuffer = NULL;
  250.     }
  251.  
  252.     if(RecordList)
  253.     {
  254.         DeleteList(RecordList);
  255.  
  256.         RecordList = NULL;
  257.     }
  258.  
  259.     RecordCount = 0;
  260. }
  261.  
  262.     /* RememberResetOutput():
  263.      *
  264.      *    Reset output monitoring.
  265.      */
  266.  
  267. VOID
  268. RememberResetOutput()
  269. {
  270.     RememberOutputSize = 0;
  271. }
  272.  
  273.     /* RememberOutputText(register STRPTR String,register LONG Size):
  274.      *
  275.      *    Remember the last ten characters received.
  276.      */
  277.  
  278. VOID __regargs
  279. RememberOutputText(register STRPTR String,register LONG Size)
  280. {
  281.     if(Size >= REMEMBER_OUT)
  282.     {
  283.         CopyMem(String + Size - REMEMBER_OUT,RememberOutputData,REMEMBER_OUT);
  284.  
  285.         RememberOutputSize = REMEMBER_OUT;
  286.     }
  287.     else
  288.     {
  289.         if(RememberOutputSize + Size > REMEMBER_OUT)
  290.         {
  291.             LONG Delta = RememberOutputSize + Size - REMEMBER_OUT,i;
  292.  
  293.             for(i = 0 ; i < RememberOutputSize - Delta ; i++)
  294.                 RememberOutputData[i] = RememberOutputData[Delta + i];
  295.  
  296.             while(i < REMEMBER_OUT)
  297.                 RememberOutputData[i++] = *String++;
  298.  
  299.             RememberOutputSize = REMEMBER_OUT;
  300.         }
  301.         else
  302.         {
  303.             CopyMem(String,&RememberOutputData[RememberOutputSize],Size);
  304.  
  305.             RememberOutputSize += Size;
  306.         }
  307.     }
  308. }
  309.  
  310.     /* RememberResetInput():
  311.      *
  312.      *    Reset input monitoring.
  313.      */
  314.  
  315. VOID
  316. RememberResetInput()
  317. {
  318.     RememberInputSize = 0;
  319. }
  320.  
  321.     /* RememberInputText(register STRPTR String,register LONG Size):
  322.      *
  323.      *    Remember the last 256 characters sent.
  324.      */
  325.  
  326. VOID __regargs
  327. RememberInputText(register STRPTR String,register LONG Size)
  328. {
  329.     if(Size >= REMEMBER_IN)
  330.     {
  331.         CopyMem(String + Size - REMEMBER_IN,RememberInputData,REMEMBER_IN);
  332.  
  333.         RememberInputSize = REMEMBER_IN;
  334.     }
  335.     else
  336.     {
  337.         if(RememberInputSize + Size > REMEMBER_IN)
  338.         {
  339.             LONG Delta = RememberInputSize + Size - REMEMBER_IN,i;
  340.  
  341.             for(i = 0 ; i < RememberInputSize - Delta ; i++)
  342.                 RememberInputData[i] = RememberInputData[Delta + i];
  343.  
  344.             while(i < REMEMBER_IN)
  345.                 RememberInputData[i++] = *String++;
  346.  
  347.             RememberInputSize = REMEMBER_IN;
  348.         }
  349.         else
  350.         {
  351.             CopyMem(String,&RememberInputData[RememberInputSize],Size);
  352.  
  353.             RememberInputSize += Size;
  354.         }
  355.     }
  356. }
  357.  
  358.     /* DoubleQuotes(STRPTR Source,LONG Len):
  359.      *
  360.      *    Double all double-quotes in the input string
  361.      *    in order to avoid trouble with the ARexx
  362.      *    parser.
  363.      */
  364.  
  365. STATIC VOID __regargs
  366. DoubleQuotes(STRPTR Source,LONG Len)
  367. {
  368.     STRPTR    Dest = RecordAuxBuffer;
  369.     LONG    i,Count = 0;
  370.  
  371.     for(i = 0 ; i < Len ; i++)
  372.     {
  373.         if(Source[i] == '\"')
  374.         {
  375.             *Dest++ = '\"';
  376.  
  377.             Count++;
  378.         }
  379.  
  380.         *Dest++ = Source[i];
  381.     }
  382.  
  383.     if(Count)
  384.     {
  385.         *Dest = 0;
  386.  
  387.         strcpy(Source,RecordAuxBuffer);
  388.     }
  389. }
  390.  
  391.     /* RememberSpill():
  392.      *
  393.      *    `Spill' the collected text, put it into the list.
  394.      */
  395.  
  396. VOID
  397. RememberSpill()
  398. {
  399.     if(RecordList)
  400.     {
  401.         struct RecordNode    *Node;
  402.         struct timeval         Delta;
  403.  
  404.             /* Calculate the difference in time
  405.              * between the last line stored and this
  406.              * line getting stored.
  407.              */
  408.  
  409.         TimeRequest -> tr_node . io_Command = TR_GETSYSTIME;
  410.  
  411.         DoIO(TimeRequest);
  412.  
  413.         Delta = TimeRequest -> tr_time;
  414.  
  415.         SubTime(&Delta,&RecordTime);
  416.  
  417.         RecordTime = TimeRequest -> tr_time;
  418.  
  419.         if(!Delta . tv_secs)
  420.             Delta . tv_secs = 1;
  421.  
  422.         Delta . tv_micro = 0;
  423.  
  424.         if(RememberOutputSize)
  425.         {
  426.             DoubleQuotes(RememberOutputData,RememberOutputSize);
  427.  
  428.             TranslateBack(RememberOutputData,RememberOutputSize,RecordAuxBuffer);
  429.  
  430.             if(Node = (struct RecordNode *)AllocVecPooled(sizeof(struct RecordNode) + strlen(RecordAuxBuffer) + 1,MEMF_ANY))
  431.             {
  432.                 Node -> Node . ln_Name = (STRPTR)(Node + 1);
  433.                 Node -> Node . ln_Type = RECORD_OUTPUT;
  434.  
  435.                 strcpy(Node -> Node . ln_Name,RecordAuxBuffer);
  436.  
  437.                 Node -> Time = Delta;
  438.  
  439.                 AddTail(RecordList,(struct Node *)Node);
  440.  
  441.                 RecordCount++;
  442.             }
  443.         }
  444.  
  445.         if(RememberInputSize)
  446.         {
  447.             DoubleQuotes(RememberInputData,RememberInputSize);
  448.  
  449.             TranslateBack(RememberInputData,RememberInputSize,RecordAuxBuffer);
  450.  
  451.             if(Node = (struct RecordNode *)AllocVecPooled(sizeof(struct RecordNode) + strlen(RecordAuxBuffer) + 1,MEMF_ANY))
  452.             {
  453.                 Node -> Node . ln_Name = (STRPTR)(Node + 1);
  454.                 Node -> Node . ln_Type = RECORD_INPUT;
  455.  
  456.                 strcpy(Node -> Node . ln_Name,RecordAuxBuffer);
  457.  
  458.                 Node -> Time = Delta;
  459.  
  460.                 AddTail(RecordList,(struct Node *)Node);
  461.  
  462.                 RecordCount++;
  463.             }
  464.         }
  465.     }
  466.  
  467.     RememberOutputSize = RememberInputSize = 0;
  468. }
  469.